package com.esri.core.geometry;

import java.io.Serializable;

/* loaded from: classes.dex */
public abstract class MultiPath extends MultiVertexGeometry implements Serializable {
    protected MultiPathImpl m_impl;

    @Override // com.esri.core.geometry.MultiVertexGeometry
    public /* bridge */ /* synthetic */ void getPoint(int i, Point point) {
        super.getPoint(i, point);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // com.esri.core.geometry.Geometry
    public VertexDescription getDescription() {
        return this.m_impl.getDescription();
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // com.esri.core.geometry.Geometry
    public void a(VertexDescription vertexDescription) {
        this.m_impl.a(vertexDescription);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // com.esri.core.geometry.Geometry
    public void mergeVertexDescription(VertexDescription vertexDescription) {
        this.m_impl.mergeVertexDescription(vertexDescription);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // com.esri.core.geometry.Geometry
    public void addAttribute(int i) {
        this.m_impl.addAttribute(i);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // com.esri.core.geometry.Geometry
    public void dropAttribute(int i) {
        this.m_impl.dropAttribute(i);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // com.esri.core.geometry.Geometry
    public void dropAllAttributes() {
        this.m_impl.dropAllAttributes();
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    public int getPointCount() {
        return this.m_impl.getPointCount();
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    public Point getPoint(int i) {
        return this.m_impl.getPoint(i);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    public void setPoint(int i, Point point) {
        this.m_impl.setPoint(i, point);
    }

    @Override // com.esri.core.geometry.Geometry
    public boolean isEmpty() {
        return this.m_impl.b();
    }

    @Override // com.esri.core.geometry.Geometry
    public double calculateArea2D() {
        return this.m_impl.calculateArea2D();
    }

    @Override // com.esri.core.geometry.Geometry
    public double calculateLength2D() {
        return this.m_impl.calculateLength2D();
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    double getAttributeAsDbl(int i, int i2, int i3) {
        return this.m_impl.getAttributeAsDbl(i, i2, i3);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    int getAttributeAsInt(int i, int i2, int i3) {
        return this.m_impl.getAttributeAsInt(i, i2, i3);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    void setAttribute(int i, int i2, int i3, double d) {
        this.m_impl.setAttribute(i, i2, i3, d);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    void setAttribute(int i, int i2, int i3, int i4) {
        this.m_impl.setAttribute(i, i2, i3, i4);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    Point2D getXY(int i) {
        return this.m_impl.getXY(i);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // com.esri.core.geometry.MultiVertexGeometry
    public void getXY(int i, Point2D point2D) {
        this.m_impl.getXY(i, point2D);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    void setXY(int i, Point2D point2D) {
        this.m_impl.setXY(i, point2D);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    Point3D getXYZ(int i) {
        return this.m_impl.getXYZ(i);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    void setXYZ(int i, Point3D point3D) {
        this.m_impl.setXYZ(i, point3D);
    }

    @Override // com.esri.core.geometry.Geometry
    public void queryEnvelope(Envelope envelope) {
        this.m_impl.queryEnvelope(envelope);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    @Override // com.esri.core.geometry.Geometry
    public void queryEnvelope2D(Envelope2D envelope2D) {
        this.m_impl.queryEnvelope2D(envelope2D);
    }

    @Override // com.esri.core.geometry.Geometry
    void queryEnvelope3D(Envelope3D envelope3D) {
        this.m_impl.queryEnvelope3D(envelope3D);
    }

    /* JADX INFO: Access modifiers changed from: package-private */
    public void a(Envelope2D envelope2D) {
        this.m_impl.queryLooseEnvelope2D(envelope2D);
    }

    void a(Envelope3D envelope3D) {
        this.m_impl.queryLooseEnvelope3D(envelope3D);
    }

    @Override // com.esri.core.geometry.Geometry
    Envelope1D queryInterval(int i, int i2) {
        return this.m_impl.queryInterval(i, i2);
    }

    @Override // com.esri.core.geometry.Geometry
    public void copyTo(Geometry geometry) {
        this.m_impl.copyTo((Geometry) geometry._getImpl());
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    void queryCoordinates(Point2D[] point2DArr) {
        this.m_impl.queryCoordinates(point2DArr);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    void queryCoordinates(Point3D[] point3DArr) {
        this.m_impl.queryCoordinates(point3DArr);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    void queryCoordinates(Point[] pointArr) {
        this.m_impl.queryCoordinates(pointArr);
    }

    boolean a() {
        return this.m_impl.hasNonLinearSegments();
    }

    public int getSegmentCount() {
        return this.m_impl.getSegmentCount();
    }

    public int getSegmentCount(int i) {
        int pathSize = getPathSize(i);
        return !isClosedPath(i) ? pathSize - 1 : pathSize;
    }

    public void add(MultiPath multiPath, boolean z) {
        this.m_impl.add((MultiPathImpl) multiPath._getImpl(), z);
    }

    public void addPath(MultiPath multiPath, int i, boolean z) {
        this.m_impl.addPath((MultiPathImpl) multiPath._getImpl(), i, z);
    }

    void a(Point2D[] point2DArr, int i, boolean z) {
        this.m_impl.addPath(point2DArr, i, z);
    }

    public void addSegment(Segment segment, boolean z) {
        this.m_impl.addSegment(segment, z);
    }

    public void reverseAllPaths() {
        this.m_impl.reverseAllPaths();
    }

    public void reversePath(int i) {
        this.m_impl.reversePath(i);
    }

    public void removePath(int i) {
        this.m_impl.removePath(i);
    }

    public void insertPath(int i, MultiPath multiPath, int i2, boolean z) {
        this.m_impl.insertPath(i, (MultiPathImpl) multiPath._getImpl(), i2, z);
    }

    void a(int i, Point2D[] point2DArr, int i2, int i3, boolean z) {
        this.m_impl.insertPath(i, point2DArr, i2, i3, z);
    }

    public void insertPoints(int i, int i2, MultiPath multiPath, int i3, int i4, int i5, boolean z) {
        this.m_impl.insertPoints(i, i2, (MultiPathImpl) multiPath._getImpl(), i3, i4, i5, z);
    }

    void a(int i, int i2, Point2D[] point2DArr, int i3, int i4, boolean z) {
        this.m_impl.insertPoints(i, i2, point2DArr, i3, i4, z);
    }

    void a(int i, int i2, Point2D point2D) {
        this.m_impl.insertPoint(i, i2, point2D);
    }

    public void insertPoint(int i, int i2, Point point) {
        this.m_impl.insertPoint(i, i2, point);
    }

    public void removePoint(int i, int i2) {
        this.m_impl.removePoint(i, i2);
    }

    public void removePoint(int i) {
        this.m_impl.removePoint(i);
    }

    public int getPathCount() {
        return this.m_impl.getPathCount();
    }

    public int getPathSize(int i) {
        return this.m_impl.getPathSize(i);
    }

    public int getPathStart(int i) {
        return this.m_impl.getPathStart(i);
    }

    public int getPathEnd(int i) {
        return this.m_impl.getPathEnd(i);
    }

    public int getPathIndexFromPointIndex(int i) {
        return this.m_impl.getPathIndexFromPointIndex(i);
    }

    public void startPath(double d, double d2) {
        this.m_impl.startPath(d, d2);
    }

    void a(Point2D point2D) {
        this.m_impl.startPath(point2D);
    }

    void a(Point3D point3D) {
        this.m_impl.startPath(point3D);
    }

    public void startPath(Point point) {
        this.m_impl.startPath(point);
    }

    public void lineTo(double d, double d2) {
        this.m_impl.lineTo(d, d2);
    }

    void b(Point2D point2D) {
        this.m_impl.lineTo(point2D);
    }

    void b(Point3D point3D) {
        this.m_impl.lineTo(point3D);
    }

    public void lineTo(Point point) {
        this.m_impl.lineTo(point);
    }

    void a(Point2D point2D, Point2D point2D2, Point2D point2D3) {
        this.m_impl.bezierTo(point2D, point2D2, point2D3);
    }

    public void closePathWithLine() {
        this.m_impl.closePathWithLine();
    }

    void a(Point2D point2D, Point2D point2D2) {
        this.m_impl.closePathWithBezier(point2D, point2D2);
    }

    void b() {
        throw new RuntimeException("not implemented");
    }

    public void closeAllPaths() {
        this.m_impl.closeAllPaths();
    }

    public boolean isClosedPath(int i) {
        return this.m_impl.isClosedPath(i);
    }

    boolean a(int i) {
        return this.m_impl.hasNonLinearSegments(i);
    }

    void a(Envelope2D envelope2D, boolean z) {
        this.m_impl.addEnvelope(envelope2D, z);
    }

    public void addEnvelope(Envelope envelope, boolean z) {
        this.m_impl.addEnvelope(envelope, z);
    }

    public SegmentIterator querySegmentIterator() {
        return new SegmentIterator(this.m_impl.querySegmentIterator());
    }

    public SegmentIterator querySegmentIteratorAtVertex(int i) {
        return new SegmentIterator(this.m_impl.querySegmentIteratorAtVertex(i));
    }

    @Override // com.esri.core.geometry.Geometry
    public void setEmpty() {
        this.m_impl.setEmpty();
    }

    @Override // com.esri.core.geometry.Geometry
    public void applyTransformation(Transformation2D transformation2D) {
        this.m_impl.applyTransformation(transformation2D);
    }

    @Override // com.esri.core.geometry.Geometry
    void applyTransformation(Transformation3D transformation3D) {
        this.m_impl.applyTransformation(transformation3D);
    }

    /* JADX INFO: Access modifiers changed from: protected */
    @Override // com.esri.core.geometry.Geometry
    public Object _getImpl() {
        return this.m_impl;
    }

    public int hashCode() {
        return this.m_impl.hashCode();
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    void a(int i, Point point) {
        this.m_impl.a(i, point);
    }

    @Override // com.esri.core.geometry.MultiVertexGeometry
    void setPointByVal(int i, Point point) {
        this.m_impl.setPointByVal(i, point);
    }

    @Override // com.esri.core.geometry.Geometry
    public int getStateFlag() {
        return this.m_impl.getStateFlag();
    }
}
